home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Stream.h < prev    next >
C/C++ Source or Header  |  1992-06-15  |  7KB  |  264 lines
  1. #ifndef Stream_First
  2. #ifdef __GNUG__
  3. //pragma once
  4. #pragma interface
  5. #endif
  6. #define Stream_First
  7.  
  8. #include "Types.h"
  9.  
  10. #ifndef BUFSIZE
  11. #define BUFSIZE 4096
  12. #endif
  13.  
  14. #ifndef EOF
  15. #define EOF (-1)
  16. #endif EOF
  17.  
  18. #define SP << ' '
  19. #define NL << '\n'
  20. #define TAB << '\t'
  21.  
  22. enum state_value {
  23.     _good   = 0,
  24.     _eof    = 1,
  25.     _fail   = 2
  26. };
  27.  
  28. class ObjArray;
  29. class Object;
  30. class OrdCollection;
  31.  
  32. enum TypeTags {
  33.     eTNone,
  34.     eTChar,
  35.     eTUChar,
  36.     eTShort,
  37.     eTUShort,
  38.     eTInt,
  39.     eTUInt,
  40.     eTLong,
  41.     eTULong,
  42.     eTFloat,
  43.     eTDouble,
  44.     eTString,
  45.     eTUString,
  46.     eTStream,
  47.     eTVoid
  48. };
  49.  
  50. //---- Stream ------------------------------------------------------------------
  51.  
  52. class Stream {
  53. protected:
  54.     ObjArray *it;
  55.     bool deepclone;
  56.     bool delete_StreamBuf;
  57.     class StreamBuf* bp;
  58.     short state;
  59.  
  60.     Stream(StreamBuf* s, bool dodelete= FALSE);
  61.         
  62. public:
  63.     virtual ~Stream();
  64.  
  65.     void Push(StreamBuf *s);
  66.     void Pop();
  67.  
  68.     operator void*()
  69.     { return _eof < state ? 0 : this; }
  70.     int operator!()
  71.     { return _eof < state; }
  72.     int eof()
  73.     { return state & _eof; }
  74.     int fail()
  75.     { return _eof < state; }
  76.     int bad()
  77.     { return _fail < state; }
  78.     int good()
  79.     { return state == _good; }
  80.     void setstate(state_value st)
  81.     { state= st; }
  82.     void clear()
  83.     { state= _good; }
  84.     int rdstate()
  85.     { return state; }
  86.     char* bufptr();
  87.     StreamBuf* getsbuf()
  88.     { return bp; }
  89.     long tell();
  90.  
  91.     // object table management
  92.     ObjArray *Table();
  93.     int IndexOfPtr(Object *op);
  94.     Object *At(int ix);
  95.     void AtPut(int ix, Object *op);
  96.     void PrepareForDeepClone()
  97.     { deepclone= TRUE; }
  98.     bool IsForDeepClone()
  99.     { return deepclone; }
  100.     int MakeIndex(Object *op);
  101.     static void InvalidatePtr(Object*);
  102.  
  103. private:
  104.     static OrdCollection *all;
  105. };
  106.  
  107. //---- OStream -----------------------------------------------------------------
  108.  
  109. class IStream;
  110.  
  111. class OStream : public Stream {
  112.     static double dd;
  113. public:
  114.     OStream(StreamBuf* s, bool dodelete= FALSE);
  115.     OStream(int fd);
  116.     OStream(int fd, char *p, int size);
  117.     OStream(int size, char *p);
  118.     OStream(char *path);
  119.     ~OStream();
  120.         
  121.     OStream& flush();
  122.     OStream& form(char* va_alist, ...);
  123.     OStream& put(char);
  124.     OStream& put(u_char);
  125.     OStream& seek(long pos, bool relative= FALSE);
  126.     OStream& rewind()
  127.     { return seek(0); }
  128.     long tell();
  129.     int write(const u_char *s, int n);
  130.     int write(const char *s, int n)
  131.     { return write((const u_char*)s, n); }
  132.  
  133.     virtual OStream& Print(int code, void *vp);
  134.  
  135.     OStream& operator<< (char c)
  136.     { return Print(eTChar, (void*) c); }
  137.     OStream& operator<< (u_char c)
  138.     { return Print(eTUChar, (void*) c); }
  139.     OStream& operator<< (const char *s)
  140.     { return Print(eTString, (void*) s); }
  141.     OStream& operator<< (const u_char *s)
  142.     { return Print(eTUString, (void*) s); }
  143.     OStream& operator<< (long l)
  144.     { return Print(eTLong, (void*) l); }
  145.     OStream& operator<< (u_long l)
  146.     { return Print(eTULong, (void*) l); }
  147.     OStream& operator<< (short s)
  148.     { return Print(eTShort, (void*) s); }
  149.     OStream& operator<< (u_short s)
  150.     { return Print(eTUShort, (void*) s); }
  151.     OStream& operator<< (int i)
  152.     { return Print(eTInt, (void*) i); }
  153.     OStream& operator<< (u_int i)
  154.     { return Print(eTUInt, (void*) i); }
  155.     OStream& operator<< (double d)
  156.     { dd= d; return Print(eTDouble, (void*) &dd); }
  157.     OStream& operator<< (float f)
  158.     { dd= f; return Print(eTFloat, (void*) &dd); }
  159.     OStream& operator<< (IStream &s)
  160.     { return Print(eTStream, (void*) &s); }
  161.     //OStream& operator<< (void *v)
  162.     //    { return Print(eTVoid, v); }
  163.  
  164.     void PutBigEndian(int bytes, long v);
  165.     OStream &PrintString(char *s, int l= -1);
  166.     OStream &PrintString(u_char *s, int l= -1)
  167.     { return PrintString((char*)s, l); }
  168.     OStream &PrintHexString(char *s, int l);
  169.     OStream &PrintHexString(u_char *s, int l)
  170.     { return PrintHexString((char*) s, l); }
  171. };
  172.  
  173. //---- IStream -----------------------------------------------------------------
  174.  
  175. /*
  176.   The >> operator reads after skipping initial whitespace
  177.   get() reads but does not skip whitespace
  178.  
  179.   if >> fails     (1) the state of the Stream turns non-zero
  180.           (2) the value of the argument does not change
  181.           (3) non-whitespace characters are put back onto the Stream
  182.  
  183.   >> get() fails if the state of the Stream is non-zero
  184. */
  185.  
  186. class IStream : public Stream {
  187.     OStream*        tied_to;
  188.  
  189. public:
  190.     IStream(StreamBuf *s, OStream *t= 0, bool dodelete= FALSE); // bind to buffer
  191.     IStream(int size, char *p);                             // bind to string
  192.     IStream(int fd, OStream *t= 0);                         // bind to file
  193.     IStream(char *path);
  194.    
  195.     void flush()
  196.     { if (tied_to) tied_to->flush(); }
  197.  
  198.     operator void*()
  199.     { return Stream::operator void*(); }
  200.     void eatwhite();
  201.     IStream& putback(char c);
  202.     IStream& seek(long pos, bool relative= FALSE);
  203.     IStream& rewind()
  204.     { return seek(0); }
  205.     long tell();
  206.     OStream* tie(OStream* s);
  207.     int read(u_char *s, int n);
  208.     int read(char *s, int n)
  209.     { return read((u_char*)s, n); }
  210.  
  211.     // raw input: get's do not skip whitespace
  212.     IStream& get(char*, int, char= '\n');           // string
  213.     IStream& get(char &c);                          // single character
  214.     IStream& get(u_char &b);                        // single unsigned character
  215.     
  216.     IStream& peek(char &c);
  217.     IStream& peek(u_char &b);
  218.     
  219.     // formatted input: >> skip whitespace
  220.     virtual IStream& Scan(int code, void *vp);
  221.  
  222.     IStream& operator>> (char *v)
  223.     { return Scan(eTString, v); }
  224.     IStream& operator>> (u_char *v)
  225.     { return Scan(eTUString, v); }
  226.     IStream& operator>> (char &v)
  227.     { return Scan(eTChar, &v); }
  228.     IStream& operator>> (u_char &v)
  229.     { return Scan(eTUChar, &v); }
  230.     IStream& operator>> (short &v)
  231.     { return Scan(eTShort, &v); }
  232.     IStream& operator>> (u_short &v)
  233.     { return Scan(eTUShort, &v); }
  234.     IStream& operator>> (int &v)
  235.     { return Scan(eTInt, &v); }
  236.     IStream& operator>> (u_int &v)
  237.     { return Scan(eTUInt, &v); }
  238.     IStream& operator>> (long &v)
  239.     { return Scan(eTLong, &v); }
  240.     IStream& operator>> (u_long &v)
  241.     { return Scan(eTULong, &v); }
  242.     IStream& operator>> (float &v)
  243.     { return Scan(eTFloat, &v); }
  244.     IStream& operator>> (double &v)
  245.     { return Scan(eTDouble, &v); }
  246.     //IStream& operator>> (Stream &v)
  247.     //    { return Scan(eTStream, &v); }
  248.  
  249.     long GetBigEndian(int bytes);
  250.     char GetChar();
  251.     u_char GetByte();
  252.  
  253.     u_char GetHex();
  254.     IStream &ReadString(char **s, int *lp= 0);
  255.     IStream &ReadString(u_char **s, int *lp= 0)
  256.     { return ReadString((char**)s, lp); }
  257. };
  258.  
  259. extern IStream cin;     // standard input predefined
  260. extern OStream cout;    // standard output
  261. extern OStream cerr;    // error output
  262.  
  263. #endif
  264.